package cn.myblog.ainblog.conroller.backstage;

import cn.myblog.ainblog.dto.CategoryDTO;
import cn.myblog.ainblog.model.CategoryModel;
import cn.myblog.ainblog.service.CategoryService;
import cn.myblog.ainblog.vo.PageVO;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * @author Dovaior
 * @Description 关于Category的控制器
 * @create 2021-04-04 20:46
 **/
@Controller
@RequestMapping("/backstage")
public class BackstageCategoryController {
    @Autowired
    private CategoryService service;

    /**
     * 添加分类（根据获取前端传递的参数）
     * @param categoryDTO 从前端接收的表单数据
     */
    @ResponseBody
    @PostMapping("/addCategory")
    public boolean addCategory(CategoryDTO categoryDTO){
        CategoryModel categoryModel = new CategoryModel();
        BeanUtils.copyProperties(categoryDTO,categoryModel);
        int i = service.addCategory(categoryModel);
        boolean flag = false;
        if (i == 1){
            flag = true;
        }else{
            flag = false;
        }
        return flag;
    }

    /**
     * 根据前端传递的ID值，查询出对应的分类信息信息并返回给前端
     * @param categoryId 从前端获取的ID值，用于根据ID查询，回显信息
     * @return 返回查询出来的信息
     */
    @ResponseBody
    @GetMapping("/updateCategoryById/{categoryId}")
    public CategoryDTO updateCategoryById(@PathVariable String categoryId){
        CategoryModel categoryModel = service.selectById(categoryId);
        CategoryDTO categoryDTO = new CategoryDTO();
        BeanUtils.copyProperties(categoryModel,categoryDTO);
        return categoryDTO;
    }

    /**
     * 执行更新，将传递过来的实体类更新
     * @param categoryDTO 从前端获取的信息进行更新操作
     * @return 返回标志给前端
     */
    @ResponseBody
    @PostMapping("/updateCategory")
    public boolean updateCategory(CategoryDTO categoryDTO){
        CategoryModel categoryModel = new CategoryModel();
        //映射实体类
        BeanUtils.copyProperties(categoryDTO,categoryModel);
        //更新
        int i = service.updateById(categoryModel);
        boolean flag = false;
        if (i == 1){
            //更新成功
            flag = true;
        }else{
            //更新失败
            flag = false;
        }
        return flag;
    }

    /**
     * 根据前端传递过来的ID值进行删除操作
     * @param categoryId 前端传递的ID值
     * @return 返回标志给前端
     */
    @ResponseBody
    @GetMapping("/deleteCategoryById/{categoryId}")
    public boolean deleteCategoryById(@PathVariable String categoryId){
        boolean flag = false;
        int i = service.deleteById(categoryId);
        if(i == 1){
            //删除成功
            flag = true;
        }else{
            //删除失败
            flag = false;
        }
        return flag;
    }

    /**
     * 根据前端传递过来的页码，查询相应页面的信息（默认一页显示两条数据）
     * @param current 传递过来的页码
     * @param model 封装查询出来的信息
     * @return 跳转页面
     */
    @GetMapping("/queryCategoryList/{current}")
    public String queryCategoryList(@PathVariable Integer current,Model model){
        //每页包含3条
        Integer size = 4;
        PageVO<CategoryModel> categoryVO = new PageVO<CategoryModel>();
        IPage<CategoryModel> page = new Page<>(current,size);
        //执行分页查询
        service.selectPage(page);
        //为分页实体类赋值
        categoryVO.setCurrent(current);
        categoryVO.setSize(size);
        //将总条数转换为页数传递给前端
        Long pageSize = page.getTotal() % size;
        if (pageSize == 0){
            categoryVO.setTotal(page.getTotal()/size);
        }else{
            //不能整除页码加一
            categoryVO.setTotal((page.getTotal()/size)+1);
        }
        //将查询到的两条信息封装到pageList当中
        categoryVO.setPageList(page.getRecords());
        model.addAttribute("categoryVO",categoryVO);
        return "backstage/backstage-categoryList";
    }

    /**
     * 用于前端验证是否存在已有的分类
     * @param categoryName 前端传递的分类名
     * @return 返回标志说明是否存在同名分类名
     */
    @ResponseBody
    @GetMapping("/selectCategoryByName/{categoryName}")
    public boolean selectCategoryByName(@PathVariable String categoryName){
        //定义一个标志
        boolean flag = false;
        QueryWrapper<CategoryModel> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("category_name",categoryName);
        //根据Name查询封装入Model
        CategoryModel categoryModel = service.selectByName(queryWrapper);
        //判断Model，若为空
        if (categoryModel == null){
            //向前端返回false
            return flag;
        }else{
            //否则向前端返回true
            flag = true;
        }
        return flag;
    }

    /**
     * 删除分类的验证，验证是否有博文调用该分类，如果有，先删除分类，反之，直接删除
     * @param categoryId 根据分类的ID查询
     * @return 返回标志
     */
    @ResponseBody
    @GetMapping("/queryArticleIdByCategoryId/{categoryId}")
    public boolean queryArticleIdByCategoryId(@PathVariable String categoryId){
        boolean flag = service.queryArticleIdByCategoryId(categoryId);
        return flag;
    }
}
